{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\numpy\\_distributor_init.py:32: UserWarning: loaded more than 1 DLL from .libs:\n",
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\numpy\\.libs\\libopenblas.NOIJJG62EMASZI6NYURL6JBKM4EVBGM7.gfortran-win_amd64.dll\n",
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\numpy\\.libs\\libopenblas.PYQHXLVVQ7VESDPUVUADXEVJOBGHJPAY.gfortran-win_amd64.dll\n",
      "  stacklevel=1)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n",
      "\tYou will need to compile a Cython extension for a portion of this assignment.\n",
      "\tThe instructions to do this will be given in a section of the notebook below.\n",
      "\tThere will be an option for Colab users and another for Jupyter (local) users.\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: forward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "[[1.79834967 1.80660132 1.81485297]\n",
      " [3.55553199 3.6141327  3.67273342]]\n",
      "[[1.49834967 1.70660132 1.91485297]\n",
      " [3.25553199 3.5141327  3.77273342]]\n",
      "difference:  9.769849468192957e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)#2*120\n",
    "weight_size = output_dim * np.prod(input_shape)#3*120\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)#(2,（4,5,6）)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)#(120,3)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)#（1,3）[-0.3 -0.1  0.1]\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "#print(x.reshape(x.shape[0], -1))\n",
    "print(x.reshape(x.shape[0], -1).dot(w))\n",
    "print(out)\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.5        -0.40909091 -0.31818182 -0.22727273]\n",
      " [-0.13636364 -0.04545455  0.04545455  0.13636364]\n",
      " [ 0.22727273  0.31818182  0.40909091  0.5       ]]\n",
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "print(x)\n",
    "out, _ = relu_forward(x)\n",
    "\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sigmod"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  2.299579177309368e-11\n",
      "dw error:  8.162011105764925e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.83e-08\n",
      "W2 relative error: 3.12e-10\n",
      "b1 relative error: 9.83e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 2.53e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.56e-08\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "tln_solver_accuracy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.304060\n",
      "(Epoch 0 / 10) train acc: 0.116000; val_acc: 0.094000\n",
      "(Iteration 101 / 4900) loss: 1.829613\n",
      "(Iteration 201 / 4900) loss: 1.857390\n",
      "(Iteration 301 / 4900) loss: 1.744448\n",
      "(Iteration 401 / 4900) loss: 1.420187\n",
      "(Epoch 1 / 10) train acc: 0.407000; val_acc: 0.422000\n",
      "(Iteration 501 / 4900) loss: 1.565913\n",
      "(Iteration 601 / 4900) loss: 1.700510\n",
      "(Iteration 701 / 4900) loss: 1.732213\n",
      "(Iteration 801 / 4900) loss: 1.688361\n",
      "(Iteration 901 / 4900) loss: 1.439529\n",
      "(Epoch 2 / 10) train acc: 0.497000; val_acc: 0.468000\n",
      "(Iteration 1001 / 4900) loss: 1.385772\n",
      "(Iteration 1101 / 4900) loss: 1.278401\n",
      "(Iteration 1201 / 4900) loss: 1.641580\n",
      "(Iteration 1301 / 4900) loss: 1.438847\n",
      "(Iteration 1401 / 4900) loss: 1.172536\n",
      "(Epoch 3 / 10) train acc: 0.490000; val_acc: 0.466000\n",
      "(Iteration 1501 / 4900) loss: 1.346286\n",
      "(Iteration 1601 / 4900) loss: 1.268492\n",
      "(Iteration 1701 / 4900) loss: 1.318215\n",
      "(Iteration 1801 / 4900) loss: 1.395750\n",
      "(Iteration 1901 / 4900) loss: 1.338233\n",
      "(Epoch 4 / 10) train acc: 0.532000; val_acc: 0.497000\n",
      "(Iteration 2001 / 4900) loss: 1.343165\n",
      "(Iteration 2101 / 4900) loss: 1.393173\n",
      "(Iteration 2201 / 4900) loss: 1.276734\n",
      "(Iteration 2301 / 4900) loss: 1.287951\n",
      "(Iteration 2401 / 4900) loss: 1.352778\n",
      "(Epoch 5 / 10) train acc: 0.525000; val_acc: 0.475000\n",
      "(Iteration 2501 / 4900) loss: 1.390234\n",
      "(Iteration 2601 / 4900) loss: 1.276361\n",
      "(Iteration 2701 / 4900) loss: 1.111768\n",
      "(Iteration 2801 / 4900) loss: 1.271688\n",
      "(Iteration 2901 / 4900) loss: 1.272039\n",
      "(Epoch 6 / 10) train acc: 0.546000; val_acc: 0.509000\n",
      "(Iteration 3001 / 4900) loss: 1.304489\n",
      "(Iteration 3101 / 4900) loss: 1.346667\n",
      "(Iteration 3201 / 4900) loss: 1.325510\n",
      "(Iteration 3301 / 4900) loss: 1.392728\n",
      "(Iteration 3401 / 4900) loss: 1.402001\n",
      "(Epoch 7 / 10) train acc: 0.567000; val_acc: 0.505000\n",
      "(Iteration 3501 / 4900) loss: 1.319024\n",
      "(Iteration 3601 / 4900) loss: 1.153287\n",
      "(Iteration 3701 / 4900) loss: 1.180922\n",
      "(Iteration 3801 / 4900) loss: 1.093164\n",
      "(Iteration 3901 / 4900) loss: 1.135902\n",
      "(Epoch 8 / 10) train acc: 0.568000; val_acc: 0.490000\n",
      "(Iteration 4001 / 4900) loss: 1.191735\n",
      "(Iteration 4101 / 4900) loss: 1.359396\n",
      "(Iteration 4201 / 4900) loss: 1.227283\n",
      "(Iteration 4301 / 4900) loss: 1.024113\n",
      "(Iteration 4401 / 4900) loss: 1.327583\n",
      "(Epoch 9 / 10) train acc: 0.592000; val_acc: 0.504000\n",
      "(Iteration 4501 / 4900) loss: 0.963330\n",
      "(Iteration 4601 / 4900) loss: 1.445619\n",
      "(Iteration 4701 / 4900) loss: 1.007542\n",
      "(Iteration 4801 / 4900) loss: 1.005175\n",
      "(Epoch 10 / 10) train acc: 0.611000; val_acc: 0.512000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "solver = Solver(model, data,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                },\n",
    "                lr_decay=0.95,\n",
    "                num_epochs=10, batch_size=100,\n",
    "                print_every=100)\n",
    "solver.train()\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.7099632369662796\n",
      "b1 relative error: 1.59e-08\n",
      "b2 relative error: 1.37e-09\n",
      "b3 relative error: 3.98e-10\n",
      "w1 relative error: 1.09e-07\n",
      "w2 relative error: 1.31e-06\n",
      "w3 relative error: 1.06e-06\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.680683920797166\n",
      "b1 relative error: 7.87e-09\n",
      "b2 relative error: 9.15e-08\n",
      "b3 relative error: 8.47e-10\n",
      "w1 relative error: 1.86e-08\n",
      "w2 relative error: 1.49e-07\n",
      "w3 relative error: 1.30e-08\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.802728\n",
      "(Epoch 0 / 20) train acc: 0.100000; val_acc: 0.104000\n",
      "(Epoch 1 / 20) train acc: 0.100000; val_acc: 0.105000\n",
      "(Epoch 2 / 20) train acc: 0.180000; val_acc: 0.111000\n",
      "(Epoch 3 / 20) train acc: 0.240000; val_acc: 0.150000\n",
      "(Epoch 4 / 20) train acc: 0.300000; val_acc: 0.160000\n",
      "(Epoch 5 / 20) train acc: 0.420000; val_acc: 0.160000\n",
      "(Iteration 11 / 40) loss: 1.804776\n",
      "(Epoch 6 / 20) train acc: 0.360000; val_acc: 0.154000\n",
      "(Epoch 7 / 20) train acc: 0.440000; val_acc: 0.168000\n",
      "(Epoch 8 / 20) train acc: 0.480000; val_acc: 0.162000\n",
      "(Epoch 9 / 20) train acc: 0.540000; val_acc: 0.163000\n",
      "(Epoch 10 / 20) train acc: 0.520000; val_acc: 0.162000\n",
      "(Iteration 21 / 40) loss: 1.425336\n",
      "(Epoch 11 / 20) train acc: 0.640000; val_acc: 0.175000\n",
      "(Epoch 12 / 20) train acc: 0.700000; val_acc: 0.182000\n",
      "(Epoch 13 / 20) train acc: 0.700000; val_acc: 0.177000\n",
      "(Epoch 14 / 20) train acc: 0.640000; val_acc: 0.173000\n",
      "(Epoch 15 / 20) train acc: 0.700000; val_acc: 0.199000\n",
      "(Iteration 31 / 40) loss: 1.270340\n",
      "(Epoch 16 / 20) train acc: 0.740000; val_acc: 0.201000\n",
      "(Epoch 17 / 20) train acc: 0.780000; val_acc: 0.183000\n",
      "(Epoch 18 / 20) train acc: 0.840000; val_acc: 0.181000\n",
      "(Epoch 19 / 20) train acc: 0.920000; val_acc: 0.173000\n",
      "(Epoch 20 / 20) train acc: 0.900000; val_acc: 0.191000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "learning_rate = 3e-3  # Experiment with this!\n",
    "weight_scale = 1e-2   # Experiment with this!\n",
    "\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 3.064093\n",
      "(Epoch 0 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 1 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 2 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 3 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 4 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 5 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Iteration 11 / 40) loss: 2.942866\n",
      "(Epoch 6 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 7 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 8 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 9 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 10 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Iteration 21 / 40) loss: 2.858432\n",
      "(Epoch 11 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 12 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 13 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 14 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 15 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Iteration 31 / 40) loss: 2.927633\n",
      "(Epoch 16 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 17 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 18 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 19 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 20 / 20) train acc: 0.100000; val_acc: 0.107000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 3e-3  # Experiment with this!\n",
    "weight_scale = 1e-2   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#在学习率相同的情况下，改变weight_scale（1e-1缩小成1e-2），看起来对five-layer network 的影响比较大"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.798492\n",
      "(Epoch 0 / 5) train acc: 0.092000; val_acc: 0.103000\n",
      "(Iteration 11 / 200) loss: 2.311890\n",
      "(Iteration 21 / 200) loss: 2.228870\n",
      "(Iteration 31 / 200) loss: 2.230586\n",
      "(Epoch 1 / 5) train acc: 0.241000; val_acc: 0.212000\n",
      "(Iteration 41 / 200) loss: 2.118543\n",
      "(Iteration 51 / 200) loss: 2.061540\n",
      "(Iteration 61 / 200) loss: 2.127194\n",
      "(Iteration 71 / 200) loss: 1.986401\n",
      "(Epoch 2 / 5) train acc: 0.251000; val_acc: 0.226000\n",
      "(Iteration 81 / 200) loss: 2.023402\n",
      "(Iteration 91 / 200) loss: 2.066924\n",
      "(Iteration 101 / 200) loss: 2.022177\n",
      "(Iteration 111 / 200) loss: 1.856185\n",
      "(Epoch 3 / 5) train acc: 0.295000; val_acc: 0.272000\n",
      "(Iteration 121 / 200) loss: 1.999585\n",
      "(Iteration 131 / 200) loss: 1.850052\n",
      "(Iteration 141 / 200) loss: 1.819052\n",
      "(Iteration 151 / 200) loss: 1.952565\n",
      "(Epoch 4 / 5) train acc: 0.299000; val_acc: 0.269000\n",
      "(Iteration 161 / 200) loss: 2.019186\n",
      "(Iteration 171 / 200) loss: 1.936993\n",
      "(Iteration 181 / 200) loss: 1.816272\n",
      "(Iteration 191 / 200) loss: 1.785001\n",
      "(Epoch 5 / 5) train acc: 0.346000; val_acc: 0.289000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 4.002187\n",
      "(Epoch 0 / 5) train acc: 0.086000; val_acc: 0.102000\n",
      "(Iteration 11 / 200) loss: 2.500800\n",
      "(Iteration 21 / 200) loss: 2.127159\n",
      "(Iteration 31 / 200) loss: 2.064419\n",
      "(Epoch 1 / 5) train acc: 0.321000; val_acc: 0.265000\n",
      "(Iteration 41 / 200) loss: 2.034169\n",
      "(Iteration 51 / 200) loss: 1.897886\n",
      "(Iteration 61 / 200) loss: 1.747990\n",
      "(Iteration 71 / 200) loss: 1.733161\n",
      "(Epoch 2 / 5) train acc: 0.403000; val_acc: 0.318000\n",
      "(Iteration 81 / 200) loss: 1.720449\n",
      "(Iteration 91 / 200) loss: 1.607360\n",
      "(Iteration 101 / 200) loss: 1.603409\n",
      "(Iteration 111 / 200) loss: 1.460936\n",
      "(Epoch 3 / 5) train acc: 0.457000; val_acc: 0.350000\n",
      "(Iteration 121 / 200) loss: 1.702910\n",
      "(Iteration 131 / 200) loss: 1.566875\n",
      "(Iteration 141 / 200) loss: 1.651549\n",
      "(Iteration 151 / 200) loss: 1.418179\n",
      "(Epoch 4 / 5) train acc: 0.482000; val_acc: 0.328000\n",
      "(Iteration 161 / 200) loss: 1.434461\n",
      "(Iteration 171 / 200) loss: 1.322329\n",
      "(Iteration 181 / 200) loss: 1.352004\n",
      "(Iteration 191 / 200) loss: 1.391556\n",
      "(Epoch 5 / 5) train acc: 0.528000; val_acc: 0.351000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:39: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:42: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:45: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:49: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  0.20720703668629928\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 3.094208\n",
      "(Epoch 0 / 5) train acc: 0.111000; val_acc: 0.099000\n",
      "(Iteration 11 / 200) loss: 2.517148\n",
      "(Iteration 21 / 200) loss: 2.175285\n",
      "(Iteration 31 / 200) loss: 2.075466\n",
      "(Epoch 1 / 5) train acc: 0.310000; val_acc: 0.246000\n",
      "(Iteration 41 / 200) loss: 1.970809\n",
      "(Iteration 51 / 200) loss: 1.940903\n",
      "(Iteration 61 / 200) loss: 1.761612\n",
      "(Iteration 71 / 200) loss: 1.770376\n",
      "(Epoch 2 / 5) train acc: 0.306000; val_acc: 0.281000\n",
      "(Iteration 81 / 200) loss: 1.716497\n",
      "(Iteration 91 / 200) loss: 1.795069\n",
      "(Iteration 101 / 200) loss: 1.648215\n",
      "(Iteration 111 / 200) loss: 1.598645\n",
      "(Epoch 3 / 5) train acc: 0.411000; val_acc: 0.308000\n",
      "(Iteration 121 / 200) loss: 1.824258\n",
      "(Iteration 131 / 200) loss: 1.661343\n",
      "(Iteration 141 / 200) loss: 1.692361\n",
      "(Iteration 151 / 200) loss: 1.539114\n",
      "(Epoch 4 / 5) train acc: 0.407000; val_acc: 0.367000\n",
      "(Iteration 161 / 200) loss: 1.461486\n",
      "(Iteration 171 / 200) loss: 1.651757\n",
      "(Iteration 181 / 200) loss: 1.526613\n",
      "(Iteration 191 / 200) loss: 1.461037\n",
      "(Epoch 5 / 5) train acc: 0.447000; val_acc: 0.374000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.657046\n",
      "(Epoch 0 / 5) train acc: 0.103000; val_acc: 0.112000\n",
      "(Iteration 11 / 200) loss: 2.105490\n",
      "(Iteration 21 / 200) loss: 1.975137\n",
      "(Iteration 31 / 200) loss: 1.949156\n",
      "(Epoch 1 / 5) train acc: 0.331000; val_acc: 0.299000\n",
      "(Iteration 41 / 200) loss: 1.675586\n",
      "(Iteration 51 / 200) loss: 1.780070\n",
      "(Iteration 61 / 200) loss: 1.781116\n",
      "(Iteration 71 / 200) loss: 1.682363\n",
      "(Epoch 2 / 5) train acc: 0.432000; val_acc: 0.317000\n",
      "(Iteration 81 / 200) loss: 1.763833\n",
      "(Iteration 91 / 200) loss: 1.624700\n",
      "(Iteration 101 / 200) loss: 1.558802\n",
      "(Iteration 111 / 200) loss: 1.399052\n",
      "(Epoch 3 / 5) train acc: 0.454000; val_acc: 0.339000\n",
      "(Iteration 121 / 200) loss: 1.529870\n",
      "(Iteration 131 / 200) loss: 1.574082\n",
      "(Iteration 141 / 200) loss: 1.497998\n",
      "(Iteration 151 / 200) loss: 1.635856\n",
      "(Epoch 4 / 5) train acc: 0.496000; val_acc: 0.349000\n",
      "(Iteration 161 / 200) loss: 1.493390\n",
      "(Iteration 171 / 200) loss: 1.308321\n",
      "(Iteration 181 / 200) loss: 1.343222\n",
      "(Iteration 191 / 200) loss: 1.503320\n",
      "(Epoch 5 / 5) train acc: 0.525000; val_acc: 0.353000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:30: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:33: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:36: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\14629\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:40: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "[cache随着迭代次数增加不断增加，导致更新w时，分母不断变大，学习到的值变小。Adam采用自适应更新学习率，没有这个缺点。\n",
    "Adam的优点主要在于经过偏置校正后，每一次迭代学习率都有个确定范围，使得参数比较平稳。]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit Metadata",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
